DataMan.java

package org.smartpaws.net;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.preference.PreferenceManager;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.loopj.android.http.AsyncHttpResponseHandler;
import com.squareup.picasso.NetworkPolicy;

import org.apache.http.Header;
import org.smartpaws.MainActivity;
import org.smartpaws.db.DBMS;
import org.smartpaws.objects.Convention;

import java.nio.channels.NotYetConnectedException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import static org.smartpaws.MainActivity.APP_NAME;

public class DataMan {

    private static final DBMS DATABASE = new DBMS(MainActivity.INSTANCE);

    public static final Gson GSON = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").serializeNulls().create();

    public static final Gson GSON_TWITTER = new GsonBuilder()
            .setDateFormat("EEE MMM dd HH:mm:ss ZZZZZ yyyy").create();

    private static final Map<String, Convention> conventions = new ConcurrentHashMap<>();

    public static DBMS getDatabase() {
        return DATABASE;
    }

    public static String getSelectedConvention(Context context) {
        try {
            return PreferenceManager.getDefaultSharedPreferences(context).getString("smartpaws.selected_convention", "confuzzled").toLowerCase();
        } catch (Exception ex) {
            return "confuzzled";
        }
    }

    public static void getConvention(final String name, final ResponseHandler<Convention> response) throws NotYetConnectedException {
        Convention result = conventions.get(name);
        if (result != null) {
            response.result(result);
            return;
        }

        NetworkInfo.State state = isNetworkConnected();
        if (state.equals(NetworkInfo.State.DISCONNECTED) || state.equals(NetworkInfo.State.DISCONNECTING)) {
            result = DATABASE.getConvention(name);
            if (result != null) {
                conventions.put(name, result);
                response.result(result);
                return;
            }
            response.result(null);
        }

        HttpClient.get(name + ".json", null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                try {
                    Convention convention = GSON.fromJson(new String(responseBody, "UTF-8"), Convention.class);
                    conventions.put(name, convention);
                    DATABASE.setConvention(name, convention);
                    response.result(convention);
                } catch (Exception ex) {
                    Log.e(APP_NAME, "", ex);
                }
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.e(APP_NAME, "HTTP Error: " + statusCode + "\nURL:" + "img/" + name + ".json", error);
            }
        });
    }

    /**
     * Get a single image
     *
     * @param name
     * @param extension
     * @param response
     *
     * @deprecated Use Picasso library
     */
    @Deprecated
    public static void getImage(final String name, final String extension, final ResponseHandler<Bitmap> response) {
        HttpClient.get("img/" + name + extension, null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                response.result(BitmapFactory.decodeByteArray(responseBody, 0, responseBody.length));
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.e(APP_NAME, "HTTP Error: " + statusCode + "\nURL:" + "img/" + name + extension, error);
            }
        });
    }

    public static void getByteArray(final String name, final String extension, final ResponseHandler<byte[]> response) {
        HttpClient.get(name + extension, null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                response.result(responseBody);
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.e(APP_NAME, "HTTP Error: " + statusCode + "\nURL:" + name + extension, error);
            }
        });
    }

    /**
     *
     * Get an image parallel to other image HTTP requests
     *
     * @param index
     * @param name
     * @param extension
     * @param response
     *
     * @deprecated Use Picasso library
    */
    @Deprecated
    public static void getParallelByteArray(final int index, final String name, final String extension, final ParallelResponseHandler<byte[]> response) {
        HttpClient.get(name + extension, null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                response.result(index, responseBody);
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.e(APP_NAME, "HTTP Error: " + statusCode + "\nURL:" + "img/" + name + extension, error);
            }
        });
    }

    /**
     * Get an externally sourced image (eg. Twitter profile picture) by using a ResponseHandler
     *
     * @param url the URL
     * @param response ResponseHandler for this image
     *
     * @deprecated Use Picasso library
     */
    @Deprecated
    public static void getExternalImage(final String url, final ResponseHandler<Bitmap> response) {
        HttpClient.getExternalUrl(url, null, new AsyncHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
                response.result(BitmapFactory.decodeByteArray(responseBody, 0, responseBody.length));
            }

            @Override
            public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
                Log.e(APP_NAME, "HTTP Error: " + statusCode + "\nURL:" + url, error);
            }
        });
    }

    public static NetworkInfo.State isNetworkConnected() {
        ConnectivityManager cm = (ConnectivityManager) MainActivity.INSTANCE.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni == null) {
            return NetworkInfo.State.DISCONNECTED;
        } else {
            return ni.getState();
        }
    }

    public static NetworkPolicy getNetworkPolicy() {
        NetworkInfo.State state = DataMan.isNetworkConnected();
        return (state.equals(NetworkInfo.State.DISCONNECTED) || state.equals(NetworkInfo.State.DISCONNECTING) ? NetworkPolicy.OFFLINE : NetworkPolicy.NO_CACHE);
    }
}